package od_2025A.one;


import java.util.*;

/**
 * todo 这道题很棒：
 *  todo 豆包针对这道题目讲解的很好，可以给豆包做；
 * 1、用到了java中重写 hashcode 和  equals方法
 * 2、用到了 hashset 和 arrayList 集合，做到了专门的数据结构做特定问题，利用空间换时间，做到了性能的提高；
 * 为什么要重写 equals 方法和 hashcode 方法呢，这要看 原来的 equals方法是干什么的？是用来比较两个对象引用是否相同；
 * 但是在这道题中，我们需要比较 两个对象的内容是否相同，所以要重写 equals 方法；
 * 那为啥要重写 hashCode 方法呢？因为在java中基于约定，两个equals相同的对象，他们的 hash值是相同的，这个是约定大于配置的思想；
 * 但是两个key 的 hash相同时，equals可能并不相同，因为hash值时 int类型，理论上只有4亿多个，所以按照鸽巢理论，当超过4亿多不同的数之后，肯定有重复的；
 * 同时 hashCode 设计在存储hash表时，发挥着关键的作用，用来定位 hash桶的位置，
 * 在java中，插入 hashMap 时，都是先通过 key的 hashCode 确定 hash桶的位置，
 * 然后再通过equals方法做比较，避免了对 hash表中的每个元素做 equals方法比较，大大节省了性能
 * 利用hashSet做contains判断的时间复杂度为O(1),利用 ArrayList的时间复杂度为O(n),需要将所有元素遍历，使用 equals方法才能找到元素是否存在，
 * 但是使用hashSet，天然的使用了 hashCode 和 equals 方法，直接就可以定位到是否有 key 存在
 * https://blog.csdn.net/qq_45776114/article/details/145847428
 * 示例：
 * 输入：
 * 4
 * 0 0
 * 1 2
 * 3 1
 * 2 -1
 * 输出：
 * 1
 */
public class Test10 {

    static class Point {
        int x;
        int y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        // 判断两个点是否相等
        @Override
        public boolean equals(Object o) {
            if (o instanceof Point) {
                Point point = (Point) o;
                return point.x == this.x && point.y == this.y;
            }
            return false;
        }

        // 重写hash方法
        @Override
        public int hashCode() {
            return Objects.hash(this.x, this.y);
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        int pointCount = Integer.parseInt(input);
        // 收集所有点
        Set<Point> pointSet = new HashSet<>(pointCount);
        List<Point> allPoint = new ArrayList<>(pointCount);
        for (int i = 0; i < pointCount; i++) {
            String[] line = scanner.nextLine().split(" ");
            Point point = new Point(Integer.parseInt(line[0]), Integer.parseInt(line[1]));
            allPoint.add(point);
            pointSet.add(point);
        }
        scanner.close();
        // 边界：四个点无法构成正方形
        if (pointCount < 4) {
            System.out.println(0);
            return;
        }
        int squareCount = 0;
        for (int i = 0; i < allPoint.size(); i++) {
            Point p1 = allPoint.get(i);
            for (int j = i + 1; j < allPoint.size(); j++) {
                Point p2 = allPoint.get(j);

                // 计算 p1 p2 坐标差
                int dx = p2.x - p1.x;
                int dy = p2.y - p1.y;
                // 计算 p1p2 矢量逆时针旋转后 获得的 p3p4矢量 （-dy,dx)
                Point p3 = new Point(p1.x - dy, p1.y + dx);
                Point p4 = new Point(p2.x - dy, p2.y + dx);
                if (pointSet.contains(p3) && pointSet.contains(p4)) {
                    squareCount++;
                }
                // 计算 p1p2 矢量顺时针旋转后 获得的 p5p6 矢量 (dy,-dx)
                Point p5 = new Point(p1.x + dy, p1.y - dx);
                Point p6 = new Point(p2.x + dy, p2.y - dx);
                if (pointSet.contains(p5) && pointSet.contains(p6)) {
                    squareCount++;
                }
            }
        }
        // 因为每个正方形都会被计算四次；所以需要除以4
        System.out.println(squareCount / 4);
    }
}
